package cn.suxiaoxiang.mmskillbar.events;

import cn.suxiaoxiang.mmskillbar.MMskillBar;
import cn.suxiaoxiang.mmskillbar.utils.*;
import io.lumine.xikage.mythicmobs.api.bukkit.events.MythicReloadedEvent;
import io.lumine.xikage.mythicmobs.io.MythicConfig;
import io.lumine.xikage.mythicmobs.items.MythicItem;
import io.lumine.xikage.mythicmobs.skills.Skill;
import io.lumine.xikage.mythicmobs.skills.SkillMetadata;
import io.lumine.xikage.mythicmobs.skills.SkillTargeter;
import io.lumine.xikage.mythicmobs.skills.SkillTrigger;
import org.bukkit.Bukkit;
import org.bukkit.boss.BossBar;
import org.bukkit.boss.BarColor;
import org.bukkit.boss.BarStyle;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.HashMap;
import java.util.Map;

public class totalEvent implements Listener {

    // 用于存储玩家和他们每个技能对应的 BossBar
    private final Map<Player, Map<String, BossBar>> playerSkillBossBarMap = new HashMap<>();
    // 用于存储玩家的冷却任务
    private final Map<Player, Map<String, BukkitRunnable>> playerSkillCooldownTasks = new HashMap<>();
    /**
     * 玩家技能事件
     */
    @EventHandler
    public void playUserSkill(PlayerInteractEvent event) {
        // 获取玩家对象
        Player player = event.getPlayer();
        // 判断是否是右键行为
        if (event.getAction().toString().contains("RIGHT")) {
            // 判断玩家是否手中有物品
            if (player.getInventory().getItemInMainHand() != null) {
                // 判断是否为MM物品
                MythicItem item = new ItemCheckListener().checkItem(player);
                if (item != null) {
                    // 得到该物品的config文件
                    MythicConfig mythicConfig = new getItemConfig().getmmItemConfig(item);
                    if (mythicConfig != null) {
                        // 得到该物品的技能名称
                        String getconfigskill = new getConfigSkill().getconfigskill(mythicConfig);
                        //判断是否释放了技能
                        boolean skillCastBoolean = new playerCastSkill().castSkill(player,getconfigskill);
                        if (getconfigskill != null && !getconfigskill.isEmpty() && skillCastBoolean) {
                            // 通过该技能名称去获取相应的配置文件
                            MythicConfig skillConfig = new getSkillConfig().getmmSkillConfig(getconfigskill);
                            if (skillConfig != null) {
                                //得到技能冷却时间
                                double skillDouble = skillConfig.getDouble("Cooldown");
                                // 判断该技能是否开启
                                boolean skillBoolean = MMskillBar.main.getConfig().getBoolean("Skills" + "." + getconfigskill);
                                if (skillBoolean && skillDouble > 0) {
                                    startCooldownTask(player, skillDouble, getconfigskill);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    @EventHandler
    public void onMythicReload(MythicReloadedEvent event) {
        // 遍历所有玩家的技能BossBar Map
        for (Player player : playerSkillBossBarMap.keySet()) {
            // 获取该玩家的技能BossBar Map
            Map<String, BossBar> skillBossBarMap = playerSkillBossBarMap.get(player);
            if (skillBossBarMap != null) {
                // 遍历该玩家的所有技能BossBar
                for (BossBar bossBar : skillBossBarMap.values()) {
                    bossBar.removePlayer(player); // 移除玩家的BossBar
                    Bukkit.getServer().getConsoleSender().sendMessage("已清除所有玩家的技能血条");
                }
                skillBossBarMap.clear(); // 清空该玩家的技能BossBar Map
            }
        }
        playerSkillBossBarMap.clear(); // 清空所有玩家的技能BossBar Map

        // 遍历所有玩家的冷却任务 Map
        for (Player player : playerSkillCooldownTasks.keySet()) {
            // 获取该玩家的冷却任务 Map
            Map<String, BukkitRunnable> skillCooldownTaskMap = playerSkillCooldownTasks.get(player);
            if (skillCooldownTaskMap != null) {
                // 遍历该玩家的所有冷却任务
                for (BukkitRunnable cooldownTask : skillCooldownTaskMap.values()) {
                    cooldownTask.cancel(); // 取消冷却任务
                }
                skillCooldownTaskMap.clear(); // 清空该玩家的冷却任务 Map
            }
        }
        playerSkillCooldownTasks.clear(); // 清空所有玩家的冷却任务 Map
    }
    /**
     * 启动冷却倒计时任务并显示BossBar
     */
    private void startCooldownTask(Player player, double cooldown, String skillName) {
        // 获取玩家的技能BossBar Map，如果没有则创建
        Map<String, BossBar> skillBossBarMap = playerSkillBossBarMap.computeIfAbsent(player, k -> new HashMap<>());
        //获取对应的血条颜色
        BarColor bossBarColor = new getConfigBossBarColor().getBossBarColor();
        //获取对应的样式
        BarStyle bossBarStyle = new getConfigBossBarStyle().getBossBarStyle();
        // 检查该玩家是否已经为该技能创建了BossBar，如果有就不再创建
        if (skillBossBarMap.containsKey(skillName)) {
            return; // 如果已经有该技能的BossBar，不再创建新的
        }

        // 创建一个新的BossBar
        BossBar bossBar = player.getServer().createBossBar(
                "mmskillbar", // 标题
                bossBarColor,    // 颜色
                bossBarStyle   // 样式
        );

        // 设置进度为100%
        bossBar.setProgress(1.0);
        bossBar.addPlayer(player); // 只显示给当前玩家

        // 将BossBar加入到该玩家的技能Map中
        skillBossBarMap.put(skillName, bossBar);

        // 启动冷却倒计时任务
        BukkitRunnable cooldownTask = new BukkitRunnable() {
            double remainingTime = cooldown;

            @Override
            public void run() {
                if (remainingTime <= 0) {
                    // 冷却结束，移除BossBar和任务
                    removeCooldown(player, skillName);
                    cancel();
                } else {
                    // 更新进度条
                    double progress = remainingTime / cooldown;
                    bossBar.setProgress(progress);

                    // 更新标题为剩余冷却时间
                    bossBar.setTitle("[" + skillName + "]技能冷却: " + (int) remainingTime + "s");

                    // 每秒减少冷却时间
                    remainingTime -= 1;
                }
            }
        };

        // 获取玩家的技能冷却任务Map，如果没有则创建
        Map<String, BukkitRunnable> skillCooldownTaskMap = playerSkillCooldownTasks.computeIfAbsent(player, k -> new HashMap<>());
        skillCooldownTaskMap.put(skillName, cooldownTask);

        // 每秒更新一次
        cooldownTask.runTaskTimer(MMskillBar.main, 0, 20);
    }

    /**
     * 移除玩家的技能冷却显示
     */
    private void removeCooldown(Player player, String skillName) {
        // 获取玩家的技能BossBar Map
        Map<String, BossBar> skillBossBarMap = playerSkillBossBarMap.get(player);

        // 移除该技能的BossBar
        if (skillBossBarMap != null && skillBossBarMap.containsKey(skillName)) {
            BossBar bossBar = skillBossBarMap.get(skillName);
            bossBar.removePlayer(player);  // 移除玩家的BossBar
            skillBossBarMap.remove(skillName); // 从map中删除该技能的BossBar
        }

        // 获取玩家的技能冷却任务Map
        Map<String, BukkitRunnable> skillCooldownTaskMap = playerSkillCooldownTasks.get(player);

        // 取消并移除该技能的冷却任务
        if (skillCooldownTaskMap != null && skillCooldownTaskMap.containsKey(skillName)) {
            BukkitRunnable cooldownTask = skillCooldownTaskMap.get(skillName);
            cooldownTask.cancel();  // 取消冷却任务
            skillCooldownTaskMap.remove(skillName);  // 从map中删除该技能的任务
        }

        // 清理玩家冷却和BossBar映射
        if (skillBossBarMap.isEmpty()) {
            playerSkillBossBarMap.remove(player);
        }

        if (skillCooldownTaskMap.isEmpty()) {
            playerSkillCooldownTasks.remove(player);
        }
    }
}
